[dev.power64] code review 152570049: all: merge default into dev.power64

src/runtime/os_solaris.c

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
 #include "textflag.h"
@@ skipping 103 matching lines @@
         runtime·ncpu = getncpu();·
 }
 
 void
 runtime·newosproc(M *mp, void *stk)
 {
         PthreadAttr attr;
         Sigset oset;
         Pthread tid;
         int32 ret;
+        uint64 size;
 
         USED(stk);
         if(runtime·pthread_attr_init(&attr) != 0)
                 runtime·throw("pthread_attr_init");
         if(runtime·pthread_attr_setstack(&attr, 0, 0x200000) != 0)
                 runtime·throw("pthread_attr_setstack");
-        if(runtime·pthread_attr_getstack(&attr, (void**)&mp->g0->stackbase, &mp->g0->stacksize) != 0)
+        size = 0;
+        if(runtime·pthread_attr_getstack(&attr, (void**)&mp->g0->stack.hi, &size) != 0)
                 runtime·throw("pthread_attr_getstack");·
+        mp->g0->stack.lo = mp->g0->stack.hi - size;
         if(runtime·pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
                 runtime·throw("pthread_attr_setdetachstate");
 
         // Disable signals during create, so that the new thread starts
         // with signals disabled.  It will enable them in minit.
         runtime·sigprocmask(SIG_SETMASK, &sigset_all, &oset);
         ret = runtime·pthread_create(&tid, &attr, (void (*)(void))runtime·tstart_sysvicall, mp);
         runtime·sigprocmask(SIG_SETMASK, &oset, nil);
         if(ret != 0) {
                 runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount(), ret);
@@ skipping 34 matching lines @@
         mp->gsignal->m = mp;
 }
 
 // Called to initialize a new m (including the bootstrap m).
 // Called on the new thread, can not allocate memory.
 void
 runtime·minit(void)
 {
         runtime·asmcgocall(runtime·miniterrno, (void *)libc·___errno);
         // Initialize signal handling
-        runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+        runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
         runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
 }
 
 // Called from dropm to undo the effect of an minit.
 void
 runtime·unminit(void)
 {
         runtime·signalstack(nil, 0);
 }
 
-void
-runtime·sigpanic(void)
-{
-        if(!runtime·canpanic(g))
-                runtime·throw("unexpected signal during runtime execution");
-
-        switch(g->sig) {
-        case SIGBUS:
-                if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000 || g->paniconfault) {
-                        if(g->sigpc == 0)
-                                runtime·panicstring("call of nil func value");
-                        runtime·panicstring("invalid memory address or nil pointer dereference");
-                }
-                runtime·printf("unexpected fault address %p\n", g->sigcode1);
-                runtime·throw("fault");
-        case SIGSEGV:
-                if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000 || g->paniconfault) {
-                        if(g->sigpc == 0)
-                                runtime·panicstring("call of nil func value");
-                        runtime·panicstring("invalid memory address or nil pointer dereference");
-                }
-                runtime·printf("unexpected fault address %p\n", g->sigcode1);
-                runtime·throw("fault");
-        case SIGFPE:
-                switch(g->sigcode0) {
-                case FPE_INTDIV:
-                        runtime·panicstring("integer divide by zero");
-                case FPE_INTOVF:
-                        runtime·panicstring("integer overflow");
-                }
-                runtime·panicstring("floating point error");
-        }
-        runtime·panicstring(runtime·sigtab[g->sig].name);
-}
-
 uintptr
 runtime·memlimit(void)
 {
         Rlimit rl;
         extern byte runtime·text[], runtime·end[];
         uintptr used;
 ········
         if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
                 return 0;
         if(rl.rlim_cur >= 0x7fffffff)
@@ skipping 75 matching lines @@
 
 #pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
         SemT* sem;
 
         // Call libc's malloc rather than runtime·malloc.  This will
         // allocate space on the C heap.  We can't call runtime·malloc
         // here because it could cause a deadlock.
-        g->m->libcall.fn = (void*)libc·malloc;
+        g->m->libcall.fn = (uintptr)(void*)libc·malloc;
         g->m->libcall.n = 1;
         runtime·memclr((byte*)&g->m->scratch, sizeof(g->m->scratch));
         g->m->scratch.v[0] = (uintptr)sizeof(*sem);
-        g->m->libcall.args = (uintptr*)&g->m->scratch;
+        g->m->libcall.args = (uintptr)(uintptr*)&g->m->scratch;
         runtime·asmcgocall(runtime·asmsysvicall6, &g->m->libcall);
         sem = (void*)g->m->libcall.r1;
         if(runtime·sem_init(sem, 0, 0) != 0)
                 runtime·throw("sem_init");
         return (uintptr)sem;
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·semasleep(int64 ns)
 {
         M *m;
 
         m = g->m;
         if(ns >= 0) {
                 m->ts.tv_sec = ns / 1000000000LL;
                 m->ts.tv_nsec = ns % 1000000000LL;
 
-                m->libcall.fn = (void*)libc·sem_reltimedwait_np;
+                m->libcall.fn = (uintptr)(void*)libc·sem_reltimedwait_np;
                 m->libcall.n = 2;
                 runtime·memclr((byte*)&m->scratch, sizeof(m->scratch));
                 m->scratch.v[0] = m->waitsema;
                 m->scratch.v[1] = (uintptr)&m->ts;
-                m->libcall.args = (uintptr*)&m->scratch;
+                m->libcall.args = (uintptr)(uintptr*)&m->scratch;
                 runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
                 if(*m->perrno != 0) {
                         if(*m->perrno == ETIMEDOUT || *m->perrno == EAGAIN || *m->perrno == EINTR)
                                 return -1;
                         runtime·throw("sem_reltimedwait_np");
                 }
                 return 0;
         }
         for(;;) {
-                m->libcall.fn = (void*)libc·sem_wait;
+                m->libcall.fn = (uintptr)(void*)libc·sem_wait;
                 m->libcall.n = 1;
                 runtime·memclr((byte*)&m->scratch, sizeof(m->scratch));
                 m->scratch.v[0] = m->waitsema;
-                m->libcall.args = (uintptr*)&m->scratch;
+                m->libcall.args = (uintptr)(uintptr*)&m->scratch;
                 runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
                 if(m->libcall.r1 == 0)
                         break;
                 if(*m->perrno == EINTR)·
                         continue;
                 runtime·throw("sem_wait");
         }
         return 0;
 }
 
@@ skipping 193 matching lines @@
 runtime·osyield(void)
 {
         // Check the validity of m because we might be called in cgo callback
         // path early enough where there isn't a m available yet.
         if(g && g->m != nil) {
                 runtime·sysvicall0(libc·sched_yield);
                 return;
         }
         runtime·osyield1();
 }
+
+#pragma textflag NOSPLIT
+int8*
+runtime·signame(int32 sig)
+{
+        return runtime·sigtab[sig].name;
+}