all: merge NaCl branch (part 1)

src/pkg/runtime/traceback_x86.c

 // Copyright 2009 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.
 
-// +build amd64 386
+// +build amd64 amd64p32 386
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "funcdata.h"
 
 void runtime·sigpanic(void);
 
 // This code is also used for the 386 tracebacks.
 // Use uintptr for an appropriate word-sized integer.
@@ skipping 29 matching lines @@
         runtime·memclr((byte*)&frame, sizeof frame);
         frame.pc = pc0;
         frame.sp = sp0;
         waspanic = false;
         printing = pcbuf==nil && callback==nil;
 ········
         // If the PC is zero, it's likely a nil function call.
         // Start in the caller's frame.
         if(frame.pc == 0) {
                 frame.pc = *(uintptr*)frame.sp;
-                frame.sp += sizeof(uintptr);
+                frame.sp += sizeof(uintreg);
         }
 ········
         f = runtime·findfunc(frame.pc);
         if(f == nil) {
                 if(callback != nil) {
                         runtime·printf("runtime: unknown pc %p\n", frame.pc);
                         runtime·throw("unknown pc");
                 }
                 return 0;
         }
@@ skipping 28 matching lines @@
                         }
                         frame.fn = f;
                         continue;
                 }
                 f = frame.fn;
 
                 // Found an actual function.
                 // Derive frame pointer and link register.
                 if(frame.fp == 0) {
                         frame.fp = frame.sp + runtime·funcspdelta(f, frame.pc);
-                        frame.fp += sizeof(uintptr); // caller PC
+                        frame.fp += sizeof(uintreg); // caller PC
                 }
                 if(runtime·topofstack(f)) {
                         frame.lr = 0;
                         flr = nil;
                 } else {
                         if(frame.lr == 0)
-                                frame.lr = ((uintptr*)frame.fp)[-1];
+                                frame.lr = ((uintreg*)frame.fp)[-1];
                         flr = runtime·findfunc(frame.lr);
                         if(flr == nil) {
                                 runtime·printf("runtime: unexpected return pc for %s called from %p\n", runtime·funcname(f), frame.lr);
                                 if(callback != nil)
                                         runtime·throw("unknown caller pc");
                         }
                 }
 ················
-                frame.varp = (byte*)frame.fp - sizeof(uintptr);
+                frame.varp = (byte*)frame.fp - sizeof(uintreg);
 
                 // Derive size of arguments.
                 // Most functions have a fixed-size argument block,
                 // so we can use metadata about the function f.
                 // Not all, though: there are some variadic functions
                 // in package runtime and reflect, and for those we use call-specific
                 // metadata recorded by f's caller.
                 if(callback != nil || printing) {
                         frame.argp = (byte*)frame.fp;
                         if(f->args != ArgsSizeUnknown)
@@ skipping 124 matching lines @@
 int32
 runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
 {
         uintptr pc, sp;
 
         sp = runtime·getcallersp(&skip);
         pc = (uintptr)runtime·getcallerpc(&skip);
 
         return runtime·gentraceback(pc, sp, 0, g, skip, pcbuf, m, nil, nil, false);
 }