ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/MacOSX/main_macosx.mm
(Generate patch)

Comparing BasiliskII/src/MacOSX/main_macosx.mm (file contents):
Revision 1.12 by nigel, 2004-01-27T00:18:24Z vs.
Revision 1.20 by nigel, 2008-02-04T01:00:53Z

# Line 5 | Line 5
5   *                                              Based (in a small way) on the default main.m,
6                                                  and on Basilisk's main_unix.cpp
7   *
8 < *  Basilisk II (C) 1997-2004 Christian Bauer
8 > *  Basilisk II (C) 1997-2008 Christian Bauer
9   *
10   *  This program is free software; you can redistribute it and/or modify
11   *  it under the terms of the GNU General Public License as published by
# Line 21 | Line 21
21   *  along with this program; if not, write to the Free Software
22   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23   */
24 +
25 + #import <AppKit/AppKit.h>
26 + #undef check
27 +
28   #define PTHREADS        // Why is this here?
29   #include "sysdeps.h"
30  
# Line 50 | Line 54 | using std::string;
54   #include "xpram.h"
55  
56   #if USE_JIT
57 < extern void flush_icache_range(uint32 start, uint32 size);  // from compemu_support.cpp
57 > extern void flush_icache_range(uint8 *start, uint32 size);  // from compemu_support.cpp
58   #endif
59  
60   #ifdef ENABLE_MON
# Line 61 | Line 65 | extern void flush_icache_range(uint32 st
65   #include "debug.h"
66  
67  
64 – #import <AppKit/AppKit.h>
65 –
68   #include "main_macosx.h"                // To bridge between main() and misc. classes
69  
70  
# Line 71 | Line 73 | const char ROM_FILE_NAME[] = "ROM";
73   const int SCRATCH_MEM_SIZE = 0x10000;   // Size of scratch memory area
74  
75  
76 + static char *bundle = NULL;             // If in an OS X application bundle, its path
77 +
78 +
79   // CPU and FPU type, addressing mode
80   int CPUType;
81   bool CPUIs68060;
# Line 108 | Line 113 | static bool lm_area_mapped = false;    // F
113  
114  
115   /*
116 + *  Helpers to map memory that can be accessed from the Mac side
117 + */
118 +
119 + // NOTE: VM_MAP_32BIT is only used when compiling a 64-bit JIT on specific platforms
120 + void *vm_acquire_mac(size_t size)
121 + {
122 +        return vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
123 + }
124 +
125 + static int vm_acquire_mac_fixed(void *addr, size_t size)
126 + {
127 +        return vm_acquire_fixed(addr, size, VM_MAP_DEFAULT | VM_MAP_32BIT);
128 + }
129 +
130 +
131 + /*
132   *  SIGSEGV handler
133   */
134  
135 < static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address,
115 <                                                                                sigsegv_address_t fault_instruction)
135 > static sigsegv_return_t sigsegv_handler(sigsegv_info_t *sip)
136   {
137 +        const uintptr fault_address = (uintptr)sigsegv_get_fault_address(sip);
138   #if ENABLE_VOSF
139          // Handle screen fault
140 <        extern bool Screen_fault_handler(sigsegv_address_t, sigsegv_address_t);
141 <        if (Screen_fault_handler(fault_address, fault_instruction))
140 >        extern bool Screen_fault_handler(sigsegv_info_t *sip);
141 >        if (Screen_fault_handler(sip))
142                  return SIGSEGV_RETURN_SUCCESS;
143   #endif
144  
# Line 139 | Line 160 | static sigsegv_return_t sigsegv_handler(
160   *  Dump state when everything went wrong after a SEGV
161   */
162  
163 < static void sigsegv_dump_state(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
163 > static void sigsegv_dump_state(sigsegv_info_t *sip)
164   {
165 +        const sigsegv_address_t fault_address = sigsegv_get_fault_address(sip);
166 +        const sigsegv_address_t fault_instruction = sigsegv_get_fault_instruction_address(sip);
167          fprintf(stderr, "Caught SIGSEGV at address %p", fault_address);
168 <        if (fault_instruction != SIGSEGV_INVALID_PC)
168 >        if (fault_instruction != SIGSEGV_INVALID_ADDRESS)
169                  fprintf(stderr, " [IP=%p]", fault_instruction);
170          fprintf(stderr, "\n");
171          uaecptr nextpc;
# Line 156 | Line 179 | static void sigsegv_dump_state(sigsegv_a
179   #ifdef ENABLE_MON
180          char *arg[4] = {"mon", "-m", "-r", NULL};
181          mon(3, arg);
159 –        QuitEmulator();
182   #endif
183 +        QuitEmulator();
184 + }
185 +
186 +
187 + /*
188 + * Screen fault handler
189 + */
190 +
191 + bool Screen_fault_handler(sigsegv_info_t *sip)
192 + {
193 +        return true;
194   }
195  
196  
# Line 221 | Line 254 | int main(int argc, char **argv)
254          // Init system routines
255          SysInit();
256  
257 +        // Set the current directory somewhere useful.
258 +        // Handy for storing the ROM file
259 +        bundle = strstr(argv[0], "BasiliskII.app/Contents/MacOS/BasiliskII");
260 +        if (bundle)
261 +        {
262 +                while (*bundle != '/')
263 +                        ++bundle;
264 +
265 +                *bundle = 0;  // Throw away Contents/... on end of argv[0]
266 +                bundle = argv[0];
267 +
268 +                chdir(bundle);
269 +        }
270 +
271          // Open display, attach to window server,
272          // load pre-instantiated classes from MainMenu.nib, start run loop
273          int i = NSApplicationMain(argc, (const char **)argv);
# Line 258 | Line 305 | bool InitEmulator (void)
305                  WarningAlert(GetString(STR_SMALL_RAM_WARN));
306                  RAMSize = 1024*1024;
307          }
308 +        if (RAMSize > 1023*1024*1024)                                           // Cap to 1023MB (APD crashes at 1GB)
309 +                RAMSize = 1023*1024*1024;
310  
311   #if REAL_ADDRESSING || DIRECT_ADDRESSING
312          RAMSize = RAMSize & -getpagesize();                                     // Round down to page boundary
# Line 269 | Line 318 | bool InitEmulator (void)
318   #if REAL_ADDRESSING
319          // Flag: RAM and ROM are contigously allocated from address 0
320          bool memory_mapped_from_zero = false;
321 <        
322 <        // Under Solaris/SPARC and NetBSD/m68k, Basilisk II is known to crash
323 <        // when trying to map a too big chunk of memory starting at address 0
324 < #if defined(OS_solaris) || defined(OS_netbsd) || defined(PAGEZERO_HACK)
325 <        const bool can_map_all_memory = false;
277 < #else
321 >
322 >        // Make sure to map RAM & ROM at address 0 only on platforms that
323 >        // supports linker scripts to relocate the Basilisk II executable
324 >        // above 0x70000000
325 > #if HAVE_LINKER_SCRIPT
326          const bool can_map_all_memory = true;
327 + #else
328 +        const bool can_map_all_memory = false;
329   #endif
330          
331          // Try to allocate all memory from 0x0000, if it is not known to crash
332 <        if (can_map_all_memory && (vm_acquire_fixed(0, RAMSize + 0x100000) == 0)) {
332 >        if (can_map_all_memory && (vm_acquire_mac_fixed(0, RAMSize + 0x100000) == 0)) {
333                  D(bug("Could allocate RAM and ROM from 0x0000\n"));
334                  memory_mapped_from_zero = true;
335          }
336 <
336 >        
337   #ifndef PAGEZERO_HACK
338          // Otherwise, just create the Low Memory area (0x0000..0x2000)
339 <        else if (vm_acquire_fixed(0, 0x2000) == 0) {
339 >        else if (vm_acquire_mac_fixed(0, 0x2000) == 0) {
340                  D(bug("Could allocate the Low Memory globals\n"));
341                  lm_area_mapped = true;
342          }
# Line 311 | Line 361 | bool InitEmulator (void)
361          else
362   #endif
363          {
364 <                RAMBaseHost = (uint8 *)vm_acquire(RAMSize);
365 <                ROMBaseHost = (uint8 *)vm_acquire(0x100000);
316 <                if (RAMBaseHost == VM_MAP_FAILED || ROMBaseHost == VM_MAP_FAILED) {
364 >                uint8 *ram_rom_area = (uint8 *)vm_acquire_mac(RAMSize + 0x100000);
365 >                if (ram_rom_area == VM_MAP_FAILED) {
366                          ErrorAlert(STR_NO_MEM_ERR);
367                          QuitEmulator();
368                  }
369 +                RAMBaseHost = ram_rom_area;
370 +                ROMBaseHost = RAMBaseHost + RAMSize;
371          }
372  
373   #if USE_SCRATCHMEM_SUBTERFUGE
374          // Allocate scratch memory
375 <        ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
375 >        ScratchMem = (uint8 *)vm_acquire_mac(SCRATCH_MEM_SIZE);
376          if (ScratchMem == VM_MAP_FAILED) {
377                  ErrorAlert(STR_NO_MEM_ERR);
378                  QuitEmulator();
# Line 336 | Line 387 | bool InitEmulator (void)
387          ROMBaseMac = Host2MacAddr(ROMBaseHost);
388   #endif
389   #if REAL_ADDRESSING
390 <        RAMBaseMac = (uint32)RAMBaseHost;
391 <        ROMBaseMac = (uint32)ROMBaseHost;
390 >        RAMBaseMac = Host2MacAddr(RAMBaseHost);
391 >        ROMBaseMac = Host2MacAddr(ROMBaseHost);
392   #endif
393          D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
394          D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
# Line 345 | Line 396 | bool InitEmulator (void)
396          // Get rom file path from preferences
397          const char *rom_path = PrefsFindString("rom");
398          if ( ! rom_path )
399 +          if ( bundle )
400 +                WarningAlert("No rom pathname set. Trying BasiliskII.app/ROM");
401 +          else
402                  WarningAlert("No rom pathname set. Trying ./ROM");
403  
404          // Load Mac ROM
# Line 405 | Line 459 | void QuitEmuNoExit()
459  
460          // Free ROM/RAM areas
461          if (RAMBaseHost != VM_MAP_FAILED) {
462 <                vm_release(RAMBaseHost, RAMSize);
462 >                vm_release(RAMBaseHost, RAMSize + 0x100000);
463                  RAMBaseHost = NULL;
410 –        }
411 –        if (ROMBaseHost != VM_MAP_FAILED) {
412 –                vm_release(ROMBaseHost, 0x100000);
464                  ROMBaseHost = NULL;
465          }
466  
# Line 439 | Line 490 | void QuitEmuNoExit()
490  
491   void QuitEmulator(void)
492   {
442 –        extern  NSApplication *NSApp;
443 –
444 –
493          QuitEmuNoExit();
494  
495          // Stop run loop?
# Line 459 | Line 507 | void QuitEmulator(void)
507   void FlushCodeCache(void *start, uint32 size)
508   {
509   #if USE_JIT
510 <    if (UseJIT)
511 <                flush_icache_range((uintptr)start, size);
510 >        if (UseJIT)
511 >                flush_icache_range((uint8 *)start, size);
512   #endif
513   }
514  
# Line 483 | Line 531 | static void sigint_handler(...)
531   #endif
532  
533  
534 + #ifdef HAVE_PTHREADS
535 + /*
536 + *  Pthread configuration
537 + */
538 +
539 + void Set_pthread_attr(pthread_attr_t *attr, int priority)
540 + {
541 +        pthread_attr_init(attr);
542 + #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
543 +        // Some of these only work for superuser
544 +        if (geteuid() == 0) {
545 +                pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED);
546 +                pthread_attr_setschedpolicy(attr, SCHED_FIFO);
547 +                struct sched_param fifo_param;
548 +                fifo_param.sched_priority = ((sched_get_priority_min(SCHED_FIFO)
549 +                                                                         + sched_get_priority_max(SCHED_FIFO))
550 +                                                                         / 2 + priority);
551 +                pthread_attr_setschedparam(attr, &fifo_param);
552 +        }
553 +        if (pthread_attr_setscope(attr, PTHREAD_SCOPE_SYSTEM) != 0) {
554 + #ifdef PTHREAD_SCOPE_BOUND_NP
555 +            // If system scope is not available (eg. we're not running
556 +            // with CAP_SCHED_MGT capability on an SGI box), try bound
557 +            // scope.  It exposes pthread scheduling to the kernel,
558 +            // without setting realtime priority.
559 +            pthread_attr_setscope(attr, PTHREAD_SCOPE_BOUND_NP);
560 + #endif
561 +        }
562 + #endif
563 + }
564 + #endif // HAVE_PTHREADS
565 +
566 +
567   /*
568   *  Mutexes
569   */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines