// 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.

#include "runtime.h"
#include "signals.h"


typedef uint64 __uint64_t;

// From /usr/include/mach/i386/_structs.h
#define	_STRUCT_X86_THREAD_STATE64	struct __darwin_x86_thread_state64
_STRUCT_X86_THREAD_STATE64
{
	__uint64_t	__rax;
	__uint64_t	__rbx;
	__uint64_t	__rcx;
	__uint64_t	__rdx;
	__uint64_t	__rdi;
	__uint64_t	__rsi;
	__uint64_t	__rbp;
	__uint64_t	__rsp;
	__uint64_t	__r8;
	__uint64_t	__r9;
	__uint64_t	__r10;
	__uint64_t	__r11;
	__uint64_t	__r12;
	__uint64_t	__r13;
	__uint64_t	__r14;
	__uint64_t	__r15;
	__uint64_t	__rip;
	__uint64_t	__rflags;
	__uint64_t	__cs;
	__uint64_t	__fs;
	__uint64_t	__gs;
};


void
print_thread_state(_STRUCT_X86_THREAD_STATE64* ss)
{
	prints("\nrax     0x");  sys_printpointer((void*)ss->__rax);
	prints("\nrbx     0x");  sys_printpointer((void*)ss->__rbx);
	prints("\nrcx     0x");  sys_printpointer((void*)ss->__rcx);
	prints("\nrdx     0x");  sys_printpointer((void*)ss->__rdx);
	prints("\nrdi     0x");  sys_printpointer((void*)ss->__rdi);
	prints("\nrsi     0x");  sys_printpointer((void*)ss->__rsi);
	prints("\nrbp     0x");  sys_printpointer((void*)ss->__rbp);
	prints("\nrsp     0x");  sys_printpointer((void*)ss->__rsp);
	prints("\nr8      0x");  sys_printpointer((void*)ss->__r8 );
	prints("\nr9      0x");  sys_printpointer((void*)ss->__r9 );
	prints("\nr10     0x");  sys_printpointer((void*)ss->__r10);
	prints("\nr11     0x");  sys_printpointer((void*)ss->__r11);
	prints("\nr12     0x");  sys_printpointer((void*)ss->__r12);
	prints("\nr13     0x");  sys_printpointer((void*)ss->__r13);
	prints("\nr14     0x");  sys_printpointer((void*)ss->__r14);
	prints("\nr15     0x");  sys_printpointer((void*)ss->__r15);
	prints("\nrip     0x");  sys_printpointer((void*)ss->__rip);
	prints("\nrflags  0x");  sys_printpointer((void*)ss->__rflags);
	prints("\ncs      0x");  sys_printpointer((void*)ss->__cs);
	prints("\nfs      0x");  sys_printpointer((void*)ss->__fs);
	prints("\ngs      0x");  sys_printpointer((void*)ss->__gs);
	prints("\n");
}


/* Code generated via: g++ -m64 signals.cc && a.out */

static void *adr_at(void *ptr, int32 offs) {
  return (void *)((uint8 *)ptr + offs);
}

static void *ptr_at(void *ptr, int32 offs) {
  return *(void **)((uint8 *)ptr + offs);
}

typedef void ucontext_t;
typedef void _STRUCT_MCONTEXT64;
typedef void _STRUCT_X86_EXCEPTION_STATE64;
typedef void _STRUCT_X86_FLOAT_STATE64;

static _STRUCT_MCONTEXT64 *get_uc_mcontext(ucontext_t *ptr) {
  return (_STRUCT_MCONTEXT64 *)ptr_at(ptr, 48);
}

static _STRUCT_X86_EXCEPTION_STATE64 *get___es(_STRUCT_MCONTEXT64 *ptr) {
  return (_STRUCT_X86_EXCEPTION_STATE64 *)adr_at(ptr, 0);
}

static _STRUCT_X86_THREAD_STATE64 *get___ss(_STRUCT_MCONTEXT64 *ptr) {
  return (_STRUCT_X86_THREAD_STATE64 *)adr_at(ptr, 16);
}

static _STRUCT_X86_FLOAT_STATE64 *get___fs(_STRUCT_MCONTEXT64 *ptr) {
  return (_STRUCT_X86_FLOAT_STATE64 *)adr_at(ptr, 184);
}

/* End of generated code */


/*
 * This assembler routine takes the args from registers, puts them on the stack,
 * and calls sighandler().
 */
extern void sigtramp();

/*
 * Rudimentary reverse-engineered definition of signal interface.
 * You'd think it would be documented.
 */
typedef struct siginfo {
	int32	si_signo;		/* signal number */
	int32	si_errno;		/* errno association */
	int32	si_code;		/* signal code */
	int32	si_pid;			/* sending process */
	int32	si_uid;			/* sender's ruid */
	int32	si_status;		/* exit value */
	void	*si_addr;		/* faulting address */
	/* more stuff here */
} siginfo;

typedef struct  sigaction {
 	union {
		void    (*sa_handler)(int32);
		void    (*sa_sigaction)(int32, siginfo *, void *);
	} u;		     /* signal handler */
	void	(*sa_trampoline)(void);	/* kernel callback point; calls sighandler() */
	uint8 sa_mask[4];		     /* signal mask to apply */
	int32     sa_flags;		     /* see signal options below */
} sigaction;

void
sighandler(int32 sig, siginfo *info, void *context)
{
	if(sig < 0 || sig >= NSIG){
		prints("Signal ");
		sys_printint(sig);
	}else{
		prints(sigtab[sig].name);
	}

        _STRUCT_MCONTEXT64 *uc_mcontext = get_uc_mcontext(context);
        _STRUCT_X86_THREAD_STATE64 *ss = get___ss(uc_mcontext);

	prints("\nFaulting address: 0x");  sys_printpointer(info->si_addr);
        prints("\npc: 0x");  sys_printpointer((void *)ss->__rip);
        prints("\n\n");
        
	traceback((void *)ss->__rip, (void *)ss->__rsp);
        print_thread_state(ss);
        
	sys_exit(2);
}

sigaction a;
extern void sigtramp(void);

void
initsig(void)
{
	int32 i;
	a.u.sa_sigaction = (void*)sigtramp;
	a.sa_flags |= 0x40;  /* SA_SIGINFO */
	for(i=0; i<sizeof(a.sa_mask); i++)
		a.sa_mask[i] = 0xFF;
	a.sa_trampoline = sigtramp;

	for(i = 0; i <NSIG; i++)
		if(sigtab[i].catch){
			sys_sigaction(i, &a, (void*)0);
		}
}