[apple/xnu.git] / osfmk / mach / i386 / sdt_isa.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _MACH_I386_SDT_ISA_H
#define	_MACH_I386_SDT_ISA_H

/*
 * Only define when testing.  This makes the calls into actual calls to
 * test functions.
 */
/* #define DTRACE_CALL_TEST */

#define DTRACE_STRINGIFY(s) #s
#define DTRACE_TOSTRING(s) DTRACE_STRINGIFY(s)
#if defined(KERNEL)
/*
 * For the kernel, set an explicit global label do the symbol can be located
 */
#define DTRACE_LAB(p, n)		\
   "__dtrace_probe$" DTRACE_TOSTRING(__LINE__) DTRACE_STRINGIFY(_##p##___##n)

#define DTRACE_LABEL(p, n)		\
      ".section __DATA, __data\n\t"	\
      ".globl " DTRACE_LAB(p, n) "\n\t"	\
       DTRACE_LAB(p, n) ":" ".long 1f""\n\t"	\
       ".text" "\n\t"			\
	"1:"
#else	/* !KERNEL */
#define DTRACE_LABEL(p, n)									\
	"__dtrace_probe$" DTRACE_TOSTRING(__LINE__) DTRACE_STRINGIFY(_##p##___##n) ":"	"\n\t"
#endif	/* !KERNEL */

#ifdef DTRACE_CALL_TEST

#define DTRACE_CALL(p,n)	\
	DTRACE_LABEL(p,n)	\
	DTRACE_CALL_INSN(p,n)

#else

#define DTRACE_CALL(p,n)	\
	DTRACE_LABEL(p,n)	\
	DTRACE_NOPS

#endif

#ifdef __x86_64__

#define DTRACE_NOPS			\
	"nop"			"\n\t"	\
	"leal 0(%%esi), %%esi"	"\n\t"	

#define DTRACE_CALL_INSN(p,n)						\
	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n)	"\n\t"

#define ARG1_EXTENT	1
#define ARGS2_EXTENT	2
#define ARGS3_EXTENT	3
#define ARGS4_EXTENT	4
#define ARGS5_EXTENT	5
#define ARGS6_EXTENT	6
#define ARGS7_EXTENT	7
#define ARGS8_EXTENT	8
#define ARGS9_EXTENT	10	
#define ARGS10_EXTENT	10	

#define DTRACE_CALL0ARGS(provider, name)							\
	asm volatile (										\
		      DTRACE_CALL(provider, name)						\
	);

#define DTRACE_CALL1ARG(provider, name)								\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi"									\
	);

#define DTRACE_CALL2ARGS(provider, name)							\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi"								\
	);

#define DTRACE_CALL3ARGS(provider, name)							\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx"							\
	);

#define DTRACE_CALL4ARGS(provider, name)							\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx"						\
	);

#define DTRACE_CALL5ARGS(provider, name)							\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
	              "movq\t0x20(%0),%%r8"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8"					\
	);

#define DTRACE_CALL6ARGS(provider, name)							\
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
	              "movq\t0x20(%0),%%r8"						"\n\t"	\
	              "movq\t0x28(%0),%%r9"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9"					\
	);

#define DTRACE_CALL7ARGS(provider, name)							\
	asm volatile ("subq\t$0x8,%%rsp"						"\n\t"	\
	              "movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
	              "movq\t0x20(%0),%%r8"						"\n\t"	\
	              "movq\t0x28(%0),%%r9"						"\n\t"	\
	              "movq\t0x30(%0),%%rax"						"\n\t"	\
	              "movq\t%%rax,0x0(%%rsp)"						"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              "addq\t$0x8,%%rsp"						"\n\t"	\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax"				\
	);

#define DTRACE_CALL8ARGS(provider, name)							\
	asm volatile ("subq\t$0x10,%%rsp"						"\n\t"	\
	              "movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
	              "movq\t0x20(%0),%%r8"						"\n\t"	\
	              "movq\t0x28(%0),%%r9"						"\n\t"	\
	              "movdqa\t0x30(%0),%%xmm1"						"\n\t"	\
	              "movdqa\t%%xmm1,0x0(%%rsp)"					"\n\t"	\
		      DTRACE_CALL(provider, name)						\
	              "addq\t$0x10,%%rsp"						"\n\t"	\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "xmm1"				\
	);

#define DTRACE_CALL9ARGS(provider, name)							\
	DTRACE_CALL10ARGS(provider, name)

#define DTRACE_CALL10ARGS(provider, name)							\
	asm volatile ("subq\t$0x20,%%rsp"						"\n\t"	\
	              "movq\t0x0(%0),%%rdi"						"\n\t"	\
	              "movq\t0x8(%0),%%rsi"						"\n\t"	\
	              "movq\t0x10(%0),%%rdx"						"\n\t"	\
	              "movq\t0x18(%0),%%rcx"						"\n\t"	\
	              "movq\t0x20(%0),%%r8"						"\n\t"	\
	              "movq\t0x28(%0),%%r9"						"\n\t"	\
	              "movdqa\t0x30(%0),%%xmm1"						"\n\t"	\
	              "movdqa\t0x40(%0),%%xmm2"						"\n\t"	\
	              "movdqa\t%%xmm1,0x0(%%rsp)"					"\n\t"	\
	              "movdqa\t%%xmm2,0x10(%%rsp)"					"\n\t"	\
	              DTRACE_CALL(provider, name)						\
	              "addq\t$0x20,%%rsp"						"\n\t"	\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "xmm1", "xmm2"			\
	);

#endif // __x86_64__

#ifdef __i386__

#define DTRACE_NOPS			\
	"nop"			"\n\t"	\
	"leal 0(%%esi), %%esi"	"\n\t"	

#define DTRACE_CALL_INSN(p,n)						\
	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n)	"\n\t"

#define ARG1_EXTENT	1
#define ARGS2_EXTENT	2
#define ARGS3_EXTENT	4
#define ARGS4_EXTENT	4
#define ARGS5_EXTENT	8
#define ARGS6_EXTENT	8
#define ARGS7_EXTENT	8
#define ARGS8_EXTENT	8
#define ARGS9_EXTENT	12	
#define ARGS10_EXTENT	12	

/*
 * Because this code is used in the kernel, we must not touch any floating point
 * or specialized registers. This leaves the following registers:
 *
 * eax ; volatile, safe to use
 * ebx ; PIC register, gcc error when used
 * ecx ; volatile, safe to use
 * edx ; volatile, safe to use
 * esi ; non-volatile, otherwise safe to use
 * edi ; non-volatile, otherwise safe to use
 *
 * Using any of the non volatile register causes a spill to stack which is almost
 * certainly a net performance loss. Also, note that the array ref (__dtrace_args)
 * consumes one free register. If all three of the volatile regs are used for load/store,
 * the compiler will spill a register to hold the array ref.
 *
 * The end result is that we only pipeline two loads/stores at a time. Blech.
 */

#define DTRACE_CALL0ARGS(provider, name)							\
	asm volatile (										\
	              DTRACE_CALL(provider, name)						\
	              "# eat trailing nl +tabfrom DTRACE_CALL"					\
	              :										\
	              :										\
	);

#define DTRACE_CALL1ARG(provider, name)								\
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x10,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)		       					\
	              : "memory", "eax"									\
	);

#define DTRACE_CALL2ARGS(provider, name)							\
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x10,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"								\
	);

#define DTRACE_CALL3ARGS(provider, name)							\
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x10,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"								\
	);

#define DTRACE_CALL4ARGS(provider, name)							\
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x10,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL5ARGS(provider, name)							\
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x20,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL6ARGS(provider, name)							\
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
		      "movl\t0x14(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x20,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL7ARGS(provider, name)							\
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
		      "movl\t0x14(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"	\
	              "movl\t0x18(%0),%%eax"						"\n\t"	\
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x20,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL8ARGS(provider, name)							\
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
		      "movl\t0x14(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"	\
	              "movl\t0x18(%0),%%eax"						"\n\t"	\
		      "movl\t0x1C(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x20,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL9ARGS(provider, name)							\
	asm volatile ("subl\t$0x30,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
		      "movl\t0x14(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"	\
	              "movl\t0x18(%0),%%eax"						"\n\t"	\
		      "movl\t0x1C(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"	\
	              "movl\t0x20(%0),%%eax"						"\n\t"	\
	              "movl\t%%eax,0x20(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x30,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#define DTRACE_CALL10ARGS(provider, name)							\
	asm volatile ("subl\t$0x30,%%esp"						"\n\t"	\
	              "movl\t0x0(%0),%%eax"						"\n\t"	\
		      "movl\t0x4(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"	\
	              "movl\t0x8(%0),%%eax"						"\n\t"	\
		      "movl\t0xC(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"	\
	              "movl\t0x10(%0),%%eax"						"\n\t"	\
		      "movl\t0x14(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"	\
	              "movl\t0x18(%0),%%eax"						"\n\t"	\
		      "movl\t0x1C(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"	\
	              "movl\t0x20(%0),%%eax"						"\n\t"	\
		      "movl\t0x24(%0),%%edx"						"\n\t"	\
	              "movl\t%%eax,0x20(%%esp)"						"\n\t"	\
	              "movl\t%%edx,0x24(%%esp)"						"\n\t"	\
	              DTRACE_CALL(provider, name)						\
                      "addl\t$0x30,%%esp"							\
	              :										\
	              : "r" (__dtrace_args)							\
	              : "memory", "eax", "edx"	       							\
	);

#endif // __i386__

#endif	/* _MACH_I386_SDT_ISA_H */
Commit	Line	Data
2d21ac55 A	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License, Version 1.0 only
	6	* (the "License"). You may not use this file except in compliance
	7	* with the License.
	8	*
	9	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	10	* or http://www.opensolaris.org/os/licensing.
	11	* See the License for the specific language governing permissions
	12	* and limitations under the License.
	13	*
	14	* When distributing Covered Code, include this CDDL HEADER in each
	15	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	16	* If applicable, add the following below this CDDL HEADER, with the
	17	* fields enclosed by brackets "[]" replaced with your own identifying
	18	* information: Portions Copyright [yyyy] [name of copyright owner]
	19	*
	20	* CDDL HEADER END
	21	*/
	22	/*
	23	* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
	24	* Use is subject to license terms.
	25	*/
	26
	27	#ifndef _MACH_I386_SDT_ISA_H
	28	#define _MACH_I386_SDT_ISA_H
	29
	30	/*
	31	* Only define when testing. This makes the calls into actual calls to
	32	* test functions.
	33	*/
	34	/* #define DTRACE_CALL_TEST */
	35
	36	#define DTRACE_STRINGIFY(s) #s
	37	#define DTRACE_TOSTRING(s) DTRACE_STRINGIFY(s)
	38	#if defined(KERNEL)
	39	/*
	40	* For the kernel, set an explicit global label do the symbol can be located
	41	*/
	42	#define DTRACE_LAB(p, n) \
	43	"__dtrace_probe$" DTRACE_TOSTRING(__LINE__) DTRACE_STRINGIFY(_##p##___##n)
	44
	45	#define DTRACE_LABEL(p, n) \
	46	".section __DATA, __data\n\t" \
	47	".globl " DTRACE_LAB(p, n) "\n\t" \
	48	DTRACE_LAB(p, n) ":" ".long 1f""\n\t" \
	49	".text" "\n\t" \
	50	"1:"
	51	#else /* !KERNEL */
	52	#define DTRACE_LABEL(p, n) \
	53	"__dtrace_probe$" DTRACE_TOSTRING(__LINE__) DTRACE_STRINGIFY(_##p##___##n) ":" "\n\t"
	54	#endif /* !KERNEL */
	55
	56	#ifdef DTRACE_CALL_TEST
	57
	58	#define DTRACE_CALL(p,n) \
	59	DTRACE_LABEL(p,n) \
	60	DTRACE_CALL_INSN(p,n)
	61
	62	#else
	63
	64	#define DTRACE_CALL(p,n) \
65	DTRACE_LABEL(p,n) \
66	DTRACE_NOPS
67
68	#endif
69
70	#ifdef __x86_64__
71
72	#define DTRACE_NOPS \
73	"nop" "\n\t" \
74	"leal 0(%%esi), %%esi" "\n\t"
75
76	#define DTRACE_CALL_INSN(p,n) \
77	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n) "\n\t"
78
79	#define ARG1_EXTENT 1
80	#define ARGS2_EXTENT 2
81	#define ARGS3_EXTENT 3
82	#define ARGS4_EXTENT 4
83	#define ARGS5_EXTENT 5
84	#define ARGS6_EXTENT 6
85	#define ARGS7_EXTENT 7
86	#define ARGS8_EXTENT 8
87	#define ARGS9_EXTENT 10
88	#define ARGS10_EXTENT 10
89
90	#define DTRACE_CALL0ARGS(provider, name) \
91	asm volatile ( \
92	DTRACE_CALL(provider, name) \
93	);
94
95	#define DTRACE_CALL1ARG(provider, name) \
96	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
97	DTRACE_CALL(provider, name) \
98	: \
99	: "r" (__dtrace_args) \
100	: "memory", "rdi" \
101	);
102
103	#define DTRACE_CALL2ARGS(provider, name) \
104	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
105	"movq\t0x8(%0),%%rsi" "\n\t" \
106	DTRACE_CALL(provider, name) \
107	: \
108	: "r" (__dtrace_args) \
109	: "memory", "rdi", "rsi" \
110	);
111
112	#define DTRACE_CALL3ARGS(provider, name) \
113	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
114	"movq\t0x8(%0),%%rsi" "\n\t" \
115	"movq\t0x10(%0),%%rdx" "\n\t" \
116	DTRACE_CALL(provider, name) \
117	: \
118	: "r" (__dtrace_args) \
119	: "memory", "rdi", "rsi", "rdx" \
120	);
121
122	#define DTRACE_CALL4ARGS(provider, name) \
123	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
124	"movq\t0x8(%0),%%rsi" "\n\t" \
125	"movq\t0x10(%0),%%rdx" "\n\t" \
126	"movq\t0x18(%0),%%rcx" "\n\t" \
127	DTRACE_CALL(provider, name) \
128	: \
129	: "r" (__dtrace_args) \
130	: "memory", "rdi", "rsi", "rdx", "rcx" \
131	);
132
133	#define DTRACE_CALL5ARGS(provider, name) \
134	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
135	"movq\t0x8(%0),%%rsi" "\n\t" \
136	"movq\t0x10(%0),%%rdx" "\n\t" \
137	"movq\t0x18(%0),%%rcx" "\n\t" \
138	"movq\t0x20(%0),%%r8" "\n\t" \
139	DTRACE_CALL(provider, name) \
140	: \
141	: "r" (__dtrace_args) \
142	: "memory", "rdi", "rsi", "rdx", "rcx", "r8" \
143	);
144
145	#define DTRACE_CALL6ARGS(provider, name) \
146	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
147	"movq\t0x8(%0),%%rsi" "\n\t" \
148	"movq\t0x10(%0),%%rdx" "\n\t" \
149	"movq\t0x18(%0),%%rcx" "\n\t" \
150	"movq\t0x20(%0),%%r8" "\n\t" \
151	"movq\t0x28(%0),%%r9" "\n\t" \
152	DTRACE_CALL(provider, name) \
153	: \
154	: "r" (__dtrace_args) \
155	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9" \
156	);
157
158	#define DTRACE_CALL7ARGS(provider, name) \
159	asm volatile ("subq\t$0x8,%%rsp" "\n\t" \
160	"movq\t0x0(%0),%%rdi" "\n\t" \
161	"movq\t0x8(%0),%%rsi" "\n\t" \
162	"movq\t0x10(%0),%%rdx" "\n\t" \
163	"movq\t0x18(%0),%%rcx" "\n\t" \
164	"movq\t0x20(%0),%%r8" "\n\t" \
165	"movq\t0x28(%0),%%r9" "\n\t" \
166	"movq\t0x30(%0),%%rax" "\n\t" \
167	"movq\t%%rax,0x0(%%rsp)" "\n\t" \
168	DTRACE_CALL(provider, name) \
169	"addq\t$0x8,%%rsp" "\n\t" \
170	: \
171	: "r" (__dtrace_args) \
172	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax" \
173	);
174
175	#define DTRACE_CALL8ARGS(provider, name) \
176	asm volatile ("subq\t$0x10,%%rsp" "\n\t" \
177	"movq\t0x0(%0),%%rdi" "\n\t" \
178	"movq\t0x8(%0),%%rsi" "\n\t" \
179	"movq\t0x10(%0),%%rdx" "\n\t" \
180	"movq\t0x18(%0),%%rcx" "\n\t" \
181	"movq\t0x20(%0),%%r8" "\n\t" \
182	"movq\t0x28(%0),%%r9" "\n\t" \
183	"movdqa\t0x30(%0),%%xmm1" "\n\t" \
184	"movdqa\t%%xmm1,0x0(%%rsp)" "\n\t" \
185	DTRACE_CALL(provider, name) \
186	"addq\t$0x10,%%rsp" "\n\t" \
187	: \
188	: "r" (__dtrace_args) \
189	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "xmm1" \
190	);
191
192	#define DTRACE_CALL9ARGS(provider, name) \
193	DTRACE_CALL10ARGS(provider, name)
194
195	#define DTRACE_CALL10ARGS(provider, name) \
196	asm volatile ("subq\t$0x20,%%rsp" "\n\t" \
197	"movq\t0x0(%0),%%rdi" "\n\t" \
198	"movq\t0x8(%0),%%rsi" "\n\t" \
199	"movq\t0x10(%0),%%rdx" "\n\t" \
200	"movq\t0x18(%0),%%rcx" "\n\t" \
201	"movq\t0x20(%0),%%r8" "\n\t" \
202	"movq\t0x28(%0),%%r9" "\n\t" \
203	"movdqa\t0x30(%0),%%xmm1" "\n\t" \
204	"movdqa\t0x40(%0),%%xmm2" "\n\t" \
205	"movdqa\t%%xmm1,0x0(%%rsp)" "\n\t" \
206	"movdqa\t%%xmm2,0x10(%%rsp)" "\n\t" \
207	DTRACE_CALL(provider, name) \
208	"addq\t$0x20,%%rsp" "\n\t" \
209	: \
210	: "r" (__dtrace_args) \
211	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "xmm1", "xmm2" \
212	);
213
214	#endif // __x86_64__
215
216	#ifdef __i386__
217
218	#define DTRACE_NOPS \
219	"nop" "\n\t" \
220	"leal 0(%%esi), %%esi" "\n\t"
221
222	#define DTRACE_CALL_INSN(p,n) \
223	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n) "\n\t"
224
225	#define ARG1_EXTENT 1
226	#define ARGS2_EXTENT 2
227	#define ARGS3_EXTENT 4
228	#define ARGS4_EXTENT 4
229	#define ARGS5_EXTENT 8
230	#define ARGS6_EXTENT 8
231	#define ARGS7_EXTENT 8
232	#define ARGS8_EXTENT 8
233	#define ARGS9_EXTENT 12
234	#define ARGS10_EXTENT 12
235
236	/*
237	* Because this code is used in the kernel, we must not touch any floating point
238	* or specialized registers. This leaves the following registers:
239	*
240	* eax ; volatile, safe to use
241	* ebx ; PIC register, gcc error when used
242	* ecx ; volatile, safe to use
243	* edx ; volatile, safe to use
244	* esi ; non-volatile, otherwise safe to use
245	* edi ; non-volatile, otherwise safe to use
246	*
247	* Using any of the non volatile register causes a spill to stack which is almost
248	* certainly a net performance loss. Also, note that the array ref (__dtrace_args)
249	* consumes one free register. If all three of the volatile regs are used for load/store,
250	* the compiler will spill a register to hold the array ref.
251	*
252	* The end result is that we only pipeline two loads/stores at a time. Blech.
253	*/
254
255	#define DTRACE_CALL0ARGS(provider, name) \
256	asm volatile ( \
257	DTRACE_CALL(provider, name) \
258	"# eat trailing nl +tabfrom DTRACE_CALL" \
259	: \
260	: \
261	);
262
263	#define DTRACE_CALL1ARG(provider, name) \
264	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
265	"movl\t0x0(%0),%%eax" "\n\t" \
266	"movl\t%%eax,0x0(%%esp)" "\n\t" \
267	DTRACE_CALL(provider, name) \
268	"addl\t$0x10,%%esp" \
269	: \
270	: "r" (__dtrace_args) \
271	: "memory", "eax" \
272	);
273
274	#define DTRACE_CALL2ARGS(provider, name) \
275	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
276	"movl\t0x0(%0),%%eax" "\n\t" \
277	"movl\t0x4(%0),%%edx" "\n\t" \
278	"movl\t%%eax,0x0(%%esp)" "\n\t" \
279	"movl\t%%edx,0x4(%%esp)" "\n\t" \
280	DTRACE_CALL(provider, name) \
281	"addl\t$0x10,%%esp" \
282	: \
283	: "r" (__dtrace_args) \
284	: "memory", "eax", "edx" \
285	);
286
287	#define DTRACE_CALL3ARGS(provider, name) \
288	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
289	"movl\t0x0(%0),%%eax" "\n\t" \
290	"movl\t0x4(%0),%%edx" "\n\t" \
291	"movl\t%%eax,0x0(%%esp)" "\n\t" \
292	"movl\t%%edx,0x4(%%esp)" "\n\t" \
293	"movl\t0x8(%0),%%eax" "\n\t" \
294	"movl\t%%eax,0x8(%%esp)" "\n\t" \
295	DTRACE_CALL(provider, name) \
296	"addl\t$0x10,%%esp" \
297	: \
298	: "r" (__dtrace_args) \
299	: "memory", "eax", "edx" \
300	);
301
302	#define DTRACE_CALL4ARGS(provider, name) \
303	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
304	"movl\t0x0(%0),%%eax" "\n\t" \
305	"movl\t0x4(%0),%%edx" "\n\t" \
306	"movl\t%%eax,0x0(%%esp)" "\n\t" \
307	"movl\t%%edx,0x4(%%esp)" "\n\t" \
308	"movl\t0x8(%0),%%eax" "\n\t" \
309	"movl\t0xC(%0),%%edx" "\n\t" \
310	"movl\t%%eax,0x8(%%esp)" "\n\t" \
311	"movl\t%%edx,0xC(%%esp)" "\n\t" \
312	DTRACE_CALL(provider, name) \
313	"addl\t$0x10,%%esp" \
314	: \
315	: "r" (__dtrace_args) \
316	: "memory", "eax", "edx" \
317	);
318
319	#define DTRACE_CALL5ARGS(provider, name) \
320	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
321	"movl\t0x0(%0),%%eax" "\n\t" \
322	"movl\t0x4(%0),%%edx" "\n\t" \
323	"movl\t%%eax,0x0(%%esp)" "\n\t" \
324	"movl\t%%edx,0x4(%%esp)" "\n\t" \
325	"movl\t0x8(%0),%%eax" "\n\t" \
326	"movl\t0xC(%0),%%edx" "\n\t" \
327	"movl\t%%eax,0x8(%%esp)" "\n\t" \
328	"movl\t%%edx,0xC(%%esp)" "\n\t" \
329	"movl\t0x10(%0),%%eax" "\n\t" \
330	"movl\t%%eax,0x10(%%esp)" "\n\t" \
331	DTRACE_CALL(provider, name) \
332	"addl\t$0x20,%%esp" \
333	: \
334	: "r" (__dtrace_args) \
335	: "memory", "eax", "edx" \
336	);
337
338	#define DTRACE_CALL6ARGS(provider, name) \
339	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
340	"movl\t0x0(%0),%%eax" "\n\t" \
341	"movl\t0x4(%0),%%edx" "\n\t" \
342	"movl\t%%eax,0x0(%%esp)" "\n\t" \
343	"movl\t%%edx,0x4(%%esp)" "\n\t" \
344	"movl\t0x8(%0),%%eax" "\n\t" \
345	"movl\t0xC(%0),%%edx" "\n\t" \
346	"movl\t%%eax,0x8(%%esp)" "\n\t" \
347	"movl\t%%edx,0xC(%%esp)" "\n\t" \
348	"movl\t0x10(%0),%%eax" "\n\t" \
349	"movl\t0x14(%0),%%edx" "\n\t" \
350	"movl\t%%eax,0x10(%%esp)" "\n\t" \
351	"movl\t%%edx,0x14(%%esp)" "\n\t" \
352	DTRACE_CALL(provider, name) \
353	"addl\t$0x20,%%esp" \
354	: \
355	: "r" (__dtrace_args) \
356	: "memory", "eax", "edx" \
357	);
358
359	#define DTRACE_CALL7ARGS(provider, name) \
360	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
361	"movl\t0x0(%0),%%eax" "\n\t" \
362	"movl\t0x4(%0),%%edx" "\n\t" \
363	"movl\t%%eax,0x0(%%esp)" "\n\t" \
364	"movl\t%%edx,0x4(%%esp)" "\n\t" \
365	"movl\t0x8(%0),%%eax" "\n\t" \
366	"movl\t0xC(%0),%%edx" "\n\t" \
367	"movl\t%%eax,0x8(%%esp)" "\n\t" \
368	"movl\t%%edx,0xC(%%esp)" "\n\t" \
369	"movl\t0x10(%0),%%eax" "\n\t" \
370	"movl\t0x14(%0),%%edx" "\n\t" \
371	"movl\t%%eax,0x10(%%esp)" "\n\t" \
372	"movl\t%%edx,0x14(%%esp)" "\n\t" \
373	"movl\t0x18(%0),%%eax" "\n\t" \
374	"movl\t%%eax,0x18(%%esp)" "\n\t" \
375	DTRACE_CALL(provider, name) \
376	"addl\t$0x20,%%esp" \
377	: \
378	: "r" (__dtrace_args) \
379	: "memory", "eax", "edx" \
380	);
381
382	#define DTRACE_CALL8ARGS(provider, name) \
383	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
384	"movl\t0x0(%0),%%eax" "\n\t" \
385	"movl\t0x4(%0),%%edx" "\n\t" \
386	"movl\t%%eax,0x0(%%esp)" "\n\t" \
387	"movl\t%%edx,0x4(%%esp)" "\n\t" \
388	"movl\t0x8(%0),%%eax" "\n\t" \
389	"movl\t0xC(%0),%%edx" "\n\t" \
390	"movl\t%%eax,0x8(%%esp)" "\n\t" \
391	"movl\t%%edx,0xC(%%esp)" "\n\t" \
392	"movl\t0x10(%0),%%eax" "\n\t" \
393	"movl\t0x14(%0),%%edx" "\n\t" \
394	"movl\t%%eax,0x10(%%esp)" "\n\t" \
395	"movl\t%%edx,0x14(%%esp)" "\n\t" \
396	"movl\t0x18(%0),%%eax" "\n\t" \
397	"movl\t0x1C(%0),%%edx" "\n\t" \
398	"movl\t%%eax,0x18(%%esp)" "\n\t" \
399	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
400	DTRACE_CALL(provider, name) \
401	"addl\t$0x20,%%esp" \
402	: \
403	: "r" (__dtrace_args) \
404	: "memory", "eax", "edx" \
405	);
406
407	#define DTRACE_CALL9ARGS(provider, name) \
408	asm volatile ("subl\t$0x30,%%esp" "\n\t" \
409	"movl\t0x0(%0),%%eax" "\n\t" \
410	"movl\t0x4(%0),%%edx" "\n\t" \
411	"movl\t%%eax,0x0(%%esp)" "\n\t" \
412	"movl\t%%edx,0x4(%%esp)" "\n\t" \
413	"movl\t0x8(%0),%%eax" "\n\t" \
414	"movl\t0xC(%0),%%edx" "\n\t" \
415	"movl\t%%eax,0x8(%%esp)" "\n\t" \
416	"movl\t%%edx,0xC(%%esp)" "\n\t" \
417	"movl\t0x10(%0),%%eax" "\n\t" \
418	"movl\t0x14(%0),%%edx" "\n\t" \
419	"movl\t%%eax,0x10(%%esp)" "\n\t" \
420	"movl\t%%edx,0x14(%%esp)" "\n\t" \
421	"movl\t0x18(%0),%%eax" "\n\t" \
422	"movl\t0x1C(%0),%%edx" "\n\t" \
423	"movl\t%%eax,0x18(%%esp)" "\n\t" \
424	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
425	"movl\t0x20(%0),%%eax" "\n\t" \
426	"movl\t%%eax,0x20(%%esp)" "\n\t" \
427	DTRACE_CALL(provider, name) \
428	"addl\t$0x30,%%esp" \
429	: \
430	: "r" (__dtrace_args) \
431	: "memory", "eax", "edx" \
432	);
433
434	#define DTRACE_CALL10ARGS(provider, name) \
435	asm volatile ("subl\t$0x30,%%esp" "\n\t" \
436	"movl\t0x0(%0),%%eax" "\n\t" \
437	"movl\t0x4(%0),%%edx" "\n\t" \
438	"movl\t%%eax,0x0(%%esp)" "\n\t" \
439	"movl\t%%edx,0x4(%%esp)" "\n\t" \
440	"movl\t0x8(%0),%%eax" "\n\t" \
441	"movl\t0xC(%0),%%edx" "\n\t" \
442	"movl\t%%eax,0x8(%%esp)" "\n\t" \
443	"movl\t%%edx,0xC(%%esp)" "\n\t" \
444	"movl\t0x10(%0),%%eax" "\n\t" \
445	"movl\t0x14(%0),%%edx" "\n\t" \
446	"movl\t%%eax,0x10(%%esp)" "\n\t" \
447	"movl\t%%edx,0x14(%%esp)" "\n\t" \
448	"movl\t0x18(%0),%%eax" "\n\t" \
449	"movl\t0x1C(%0),%%edx" "\n\t" \
450	"movl\t%%eax,0x18(%%esp)" "\n\t" \
451	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
452	"movl\t0x20(%0),%%eax" "\n\t" \
453	"movl\t0x24(%0),%%edx" "\n\t" \
454	"movl\t%%eax,0x20(%%esp)" "\n\t" \
455	"movl\t%%edx,0x24(%%esp)" "\n\t" \
456	DTRACE_CALL(provider, name) \
457	"addl\t$0x30,%%esp" \
458	: \
459	: "r" (__dtrace_args) \
460	: "memory", "eax", "edx" \
461	);
462
463	#endif // __i386__
464
465	#endif /* _MACH_I386_SDT_ISA_H */